import java.util.logging.Logger;
import org.apache.commons.codec.digest.DigestUtils;
import src.de.checker.hochzeit.domain.util.*;
import src.de.checker.hochzeit.util.*;
import src.de.checker.hochzeit.domain.user.*;
import src.de.checker.hochzeit.konstanten.*
import com.google.appengine.api.datastore.*

import static com.google.appengine.api.datastore.FetchOptions.Builder.*

Logger log = Logger.getLogger('AdminController');

def kquery = new Query(Konstanten.KATEGORIE)
kquery.addSort("id", Query.SortDirection.ASCENDING)
PreparedQuery kpreparedQuery = datastore.prepare(kquery)
def entitiesk = kpreparedQuery.asList( withLimit(100) )
request['listkat'] = entitiesk

def rquery = new Query(Konstanten.ROLLE)
rquery.addSort("id", Query.SortDirection.DESCENDING)
PreparedQuery rpreparedQuery = datastore.prepare(rquery)
def entitiesr = rpreparedQuery.asList( withLimit(100) )
request['listrole'] = entitiesr

if(params?.create ==~ /(?i)true/)
{
	forward '/admin/create.gtpl'
}
if(params?.index ==~ /(?i)true/)
{
	index()
}
if(params?.tracer ==~ /(?i)true/)
{
	tracer()
}
if(params.edit && params.edit.equalsIgnoreCase('true'))
{
	String id = params.keyid
	String kind = params.keykind
	long mid = new Long(id).longValue()
		
	Key k = KeyFactory.createKey(kind,mid)
	def entity = datastore.get(k);
	//System.out.println("Ergebnis: "+entity)
	request['gast'] =  entity
	
	forward '/admin/edit.gtpl'
}
if(params?.psw ==~ /(?i)true/)
{
	String id = params.keyid
	String kind = params.keykind
	Key k = getKey(id, kind)
	
	def nutzer = datastore.get(k);
	
	String psw = DigestUtils.md5Hex(params.passwort)//params.passwort
	
	nutzer.loginname = params.loginname
	nutzer.passwort = psw
	
	nutzer.save()
	redirect '/admin'
}
if(params?.updateuser ==~ /(?i)true/)
{
	String id = params.keyid
	String kind = params.keykind
	Key k = getKey(id, kind)
	
	def nutzer = datastore.get(k);
	
	nutzer.vorname = params.vorname
	nutzer.nachname = params.nachname
	nutzer.anzeigename = nutzer.vorname+' '+nutzer.nachname
	nutzer.strasse = params.strasse
	nutzer.plz = params.plz
	nutzer.ort = params.ort
	nutzer.anmerkung = params.anmerkung
	nutzer.rolle = new Long(params.rolle)
	nutzer.kategorie = new Long(params.kategorie)
	
	nutzer.save()
	
	redirect '/admin'
}
if(params?.delete ==~ /(?i)true/)
{
	String id = params.keyid
	String kind = params.keykind
	Key k = getKey(id, kind)
	def nutzer = datastore.get(k);
	nutzer.delete()
	log.info 'Gast wurde gelöscht'
	request.setAttribute 'message', 'Benutzer gelöscht.'
	redirect '/admin'
}
if(params?.saveuser ==~ /(?i)true/)
{
	saveuser()
	
}
if(params?.resetstatus ==~ /(?i)true/)
{
	resetStatus()
}
private void index()
{
	def query = new Query("Gaeste")
	query.addSort("nachname", Query.SortDirection.ASCENDING)
 
	// filters the entities so as to return only scripts by a certain author
	query.addFilter("rolle", Query.FilterOperator.EQUAL, new Long(0))
 
	PreparedQuery preparedQuery = datastore.prepare(query)
 
	// return only the first 10 results
	def entities = preparedQuery.asList( withLimit(100) )
	
	request['list'] = entities
	
	forward '/admin/uebersicht.gtpl'
}
private Key getKey(String id, String kind)
{
	long mid = new Long(id).longValue()
	Key k = KeyFactory.createKey(kind,mid)
	return k
}
private boolean notAll()
{
	if(!params.vorname || params.vorname.equals(''))
		return true
	if(!params.nachname || params.nachname.equals(''))
		return true
	if(!params.loginname || params.loginname.equals(''))
		return true
	if(!params.passwort || params.passwort.equals(''))
		return true
	if(!params.feier || params.feier.equals(''))
		return true
}
private void tracer()
{
	if(!params.max)
		params.max = 20
	if(!params.offset)
		params.offset = 0
	if(!params.suche)
		params.suche = ''
	if(!params.filter)
		params.filter = ''
			
	def m = (new Integer(params.max)).intValue()
	def o = (new Integer(params.offset)).intValue()
		
	def query = new Query(Konstanten.TRACER)
	
	
	//db.GqlQuery("SELECT * FROM MyModel WHERE prop >= :1 AND prop < :2", "abc", u"abc" + u"\ufffd")
	if(!params.suche.isEmpty()) {
		log.info('Tracersuche: ' + params.suche)
		query.addFilter('nachricht', Query.FilterOperator.GREATER_THAN, params.suche)
		query.addFilter('nachricht', Query.FilterOperator.LESS_THAN, params.suche + "\ufffd" )
		query.addSort("nachricht", Query.SortDirection.DESCENDING)
	} else if(!params.filter?.isEmpty()) {
		log.info('Tracersuche: ' + params.filter)
		query.addFilter('datum', Query.FilterOperator.NOT_EQUAL, null)
		query.addFilter('type', Query.FilterOperator.EQUAL, params.filter)
		query.addSort("datum", Query.SortDirection.DESCENDING)
	} else {
		query.addSort("datum", Query.SortDirection.DESCENDING)
	}
	
	PreparedQuery preparedQuery = datastore.prepare(query)
 	List<Entity> entities = preparedQuery.asList( withLimit(m).offset(o) )
 	request.list = entities
 	
 	def all = preparedQuery.countEntities();
	request['size'] = all
	request['max'] = m
	request['offset'] = o
	request['suche'] = params.suche
	request['filter'] = params.filter
	
 	def query1 = new Query(Konstanten.GAST)
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
 	List<Entity> entities1 = preparedQuery1.asList( withLimit(1000) )
 	HashMap usermap = new HashMap()
	for (i in entities1)
	{
		usermap.put (i.key, i.vorname+' '+i.nachname)
	}
 	request.usermap = usermap
	
 	if(!params.suche)
 		params.suche = ''
 	forward '/admin/tracer.gtpl'
}
private void saveuser()
{
	if(notAll())
	{
		request.setAttribute 'message', 'Alle Felder ausfüllen'
		forward '/admin/create.gtpl'
	}
	else
	{
		//Überprüfen, ob es bereits den Loginnamen gibt
		def query = new Query(Konstanten.GAST)
		query.addFilter("loginname", Query.FilterOperator.EQUAL, params.loginname)
		PreparedQuery preparedQuery = datastore.prepare(query)
	 	List<Entity> entities = preparedQuery.asList( withLimit(1) )
		 	
	 	//Es gibt bereits einen Nutzer mit diesem Loginnamen
		if(entities != null && entities.size() > 0)
		{
			request.setAttribute 'message', 'Der Loginname '+params.loginname+' ist bereits vergeben'
			forward '/admin/create.gtpl'
		}
		else
		{
			//Überprüfen, ob es bereits den Loginnamen gibt
			def queryf = new Query(Konstanten.GAST)
			queryf.addFilter("feier", Query.FilterOperator.EQUAL, params.feier.toLowerCase())
			PreparedQuery preparedQueryf = datastore.prepare(queryf)
		 	List<Entity> entitiesf = preparedQueryf.asList( withLimit(1) )
			 	
		 	//Es gibt bereits eine solche Feier
			if(entitiesf != null && entitiesf.size() > 0)
			{
				request.setAttribute 'message', 'Es gibt schon eine Feier namens '+params.feier
				forward '/admin/create.gtpl'
			}
			else
			{
				Gaeste nutzer = new Gaeste();
				
				nutzer.vorname = params.vorname
				nutzer.nachname = params.nachname
				nutzer.anzeigename = nutzer.vorname+' '+nutzer.nachname
				nutzer.rolle = new Long(0)
				nutzer.feier = params.feier.toLowerCase()
				nutzer.kategorie = new Long(0)
				nutzer.status = new Long(2)
				
				String psw = DigestUtils.md5Hex(params.passwort)//params.passwort
				
				nutzer.loginname = params.loginname
				nutzer.passwort = psw
				
				Entity e2 = nutzer as Entity
				e2.save()
				request.setAttribute 'message', 'Benutzer gespeichert.'
				index()
			}
		}
	}
}
private void resetStatus()
{
	Long status = new Long(2)
	String feier = ''
	try
	{
		status = new Long(params.statusneu)
	}
	catch(Exception e)
	{
		log.warning(e.toString())
	}
	try
	{
		if(params.feierneu && !params.feierneu.equals('') && !params.feierneu.equals('null'))
			feier = params.feierneu
	}
	catch(Exception e)
	{
		log.warning(e.toString())
	}
	log.info('Ändere Status der Gäste für die Feier: '+feier+" auf: "+status)
	
	def query = new Query(Konstanten.GAST)
	query.addFilter("feier", Query.FilterOperator.EQUAL, feier)
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(300) )
 	for(int i = 0; i<entities.size(); i++)
 	{
 		def ent = entities.get(i);
 		ent.status = status
 		ent.save()
 	}
	def query1 = new Query(Konstanten.KIND)
	query1.addFilter("feier", Query.FilterOperator.EQUAL, feier)
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
 	def entities1 = preparedQuery1.asList( withLimit(300) )
 	for(int i = 0; i<entities1.size(); i++)
 	{
 		def ent = entities1.get(i);
 		ent.status = status
 		ent.save()
 	}
	def query2 = new Query(Konstanten.ANHANG)
	query2.addFilter("feier", Query.FilterOperator.EQUAL, feier)
	PreparedQuery preparedQuery2 = datastore.prepare(query2)
 	def entities2 = preparedQuery2.asList( withLimit(300) )
 	for(int i = 0; i<entities2.size(); i++)
 	{
 		def ent = entities2.get(i);
 		ent.status = status
 		ent.save()
 	}
	redirect '/admin'
}